const feishuCrypto = require('../utils/crypto');
const config = require('../../config');
const feishuApi = require('../services/feishuApi');

class WebhookController {
  /**
   * 处理飞书webhook事件
   */
  async handleWebhook(req, res) {
    try {
      console.log('收到webhook请求:', JSON.stringify(req.body, null, 2));
      
      const { type, challenge, event } = req.body;
      
      // 处理URL验证请求
      if (type === 'url_verification') {
        return this.handleUrlVerification(challenge, res);
      }
      
      // 处理事件回调
      if (type === 'event_callback') {
        return this.handleEventCallback(event, res);
      }
      
      // 处理其他类型的请求
      console.log('未知的请求类型:', type);
      return res.status(200).json({
        code: 0,
        message: 'success'
      });
      
    } catch (error) {
      console.error('处理webhook请求失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器内部错误'
      });
    }
  }
  
  /**
   * 处理URL验证请求
   * 飞书要求返回格式: {"challenge": "xxx"}
   */
  handleUrlVerification(challenge, res) {
    console.log('处理URL验证请求, challenge:', challenge);
    
    // 飞书官方要求：只返回challenge字段
    return res.status(200).json({
      challenge: challenge
    });
  }
  
  /**
   * 处理事件回调
   */
  async handleEventCallback(event, res) {
    try {
      console.log('处理事件回调:', JSON.stringify(event, null, 2));
      
      const { type, event_id, event_type } = event;
      
      // 根据事件类型处理不同的业务逻辑
      switch (event_type) {
        case 'message':
          await this.handleMessageEvent(event);
          break;
        case 'app_mention':
          await this.handleAppMentionEvent(event);
          break;
        case 'im.message.receive_v1':
          await this.handleImMessageEvent(event);
          break;
        case 'contact.employee_change_v3':
          await this.handleEmployeeChangeEvent(event);
          break;
        default:
          console.log('未处理的事件类型:', event_type);
      }
      
      return res.status(200).json({
        code: 0,
        message: 'success'
      });
      
    } catch (error) {
      console.error('处理事件回调失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器内部错误'
      });
    }
  }
  
  /**
   * 处理消息事件
   */
  async handleMessageEvent(event) {
    try {
      console.log('处理消息事件:', JSON.stringify(event, null, 2));
      
      // 检查是否@了机器人
      const messageId = event.message_id || event.message?.message_id;
      const mentions = event.mentions || event.message?.mentions;
      
      // 如果消息中@了机器人，也处理
      if (mentions && mentions.length > 0) {
        console.log('消息中@了机器人，调用@事件处理');
        await this.handleAppMentionEvent(event);
        return;
      }
      
      // 普通消息处理逻辑
      if (messageId && event.message) {
        const messageContent = feishuApi.parseMessageContent(event.message);
        console.log('📨 收到普通消息:', messageContent);
      }
      
      // 在这里实现其他消息处理逻辑
      // 例如：自动回复、消息转发等
    } catch (error) {
      console.error('处理消息事件失败:', error);
    }
  }
  
  /**
   * 处理@机器人事件
   */
  async handleAppMentionEvent(event) {
    try {
      console.log('处理@机器人事件:', JSON.stringify(event, null, 2));
      
      // 从事件中提取消息信息
      const messageId = event.message_id || event.message?.message_id;
      const chatId = event.chat_id || event.message?.chat_id;
      const senderId = event.sender?.sender_id?.user_id || event.message?.sender?.sender_id?.user_id;
      const senderType = event.sender?.sender_type || event.message?.sender?.sender_type;
      
      console.log('消息信息:', {
        messageId,
        chatId,
        senderId,
        senderType
      });
      
      // 如果事件中直接包含消息内容，直接使用
      if (event.message && event.message.body && event.message.body.content) {
        const messageContent = feishuApi.parseMessageContent(event.message);
        console.log('📨 收到@消息内容:', messageContent);
        console.log('📋 完整消息对象:', JSON.stringify(event.message, null, 2));
        
        // 这里可以添加你的业务逻辑
        // 例如：自动回复、命令处理等
        await this.processMentionMessage({
          messageId,
          chatId,
          senderId,
          senderType,
          content: messageContent,
          fullMessage: event.message
        });
        
        return;
      }
      
      // 如果没有完整消息内容，通过API获取
      if (messageId) {
        try {
          const fullMessage = await feishuApi.getMessage(messageId);
          const messageContent = feishuApi.parseMessageContent(fullMessage);
          
          console.log('📨 通过API获取的消息内容:', messageContent);
          console.log('📋 完整消息对象:', JSON.stringify(fullMessage, null, 2));
          
          // 处理消息
          await this.processMentionMessage({
            messageId,
            chatId: fullMessage.chat_id || chatId,
            senderId: fullMessage.sender?.sender_id?.user_id || senderId,
            senderType: fullMessage.sender?.sender_type || senderType,
            content: messageContent,
            fullMessage
          });
        } catch (error) {
          console.error('通过API获取消息失败:', error);
          // 即使API调用失败，也记录事件信息
          console.log('📨 事件中的消息信息:', JSON.stringify(event, null, 2));
        }
      } else {
        // 如果没有message_id，直接输出事件信息
        console.log('⚠️ 事件中未找到message_id，输出完整事件:', JSON.stringify(event, null, 2));
      }
    } catch (error) {
      console.error('处理@机器人事件失败:', error);
      throw error;
    }
  }
  
  /**
   * 处理被@的消息内容
   * @param {object} messageInfo 消息信息
   */
  async processMentionMessage(messageInfo) {
    const { messageId, chatId, senderId, content, fullMessage } = messageInfo;
    
    console.log('========================================');
    console.log('🤖 机器人被@了！');
    console.log('========================================');
    console.log('消息ID:', messageId);
    console.log('群聊ID:', chatId);
    console.log('发送者ID:', senderId);
    console.log('消息内容:', content);
    console.log('========================================');
    
    // 在这里添加你的业务逻辑
    // 例如：
    // 1. 解析命令（如果消息是命令格式）
    // 2. 调用AI接口进行智能回复
    // 3. 执行特定操作
    // 4. 发送回复消息
    
    // 示例：简单的回复逻辑
    // if (content.includes('帮助')) {
    //   await this.sendReply(chatId, '我是飞书机器人，可以帮助你处理各种任务！');
    // }
  }
  
  /**
   * 发送回复消息
   * @param {string} chatId 群聊ID
   * @param {string} text 回复文本
   */
  async sendReply(chatId, text) {
    try {
      if (!chatId || !text) {
        console.warn('发送回复失败: chatId或text为空');
        return;
      }
      
      // 检查是否配置了App ID和Secret
      if (!feishuApi.appId || !feishuApi.appSecret) {
        console.warn('未配置App ID或App Secret，无法发送回复');
        return;
      }
      
      await feishuApi.sendMessage(
        chatId,
        'chat_id',
        'text',
        { text }
      );
      
      console.log('✅ 回复消息已发送:', text);
    } catch (error) {
      console.error('发送回复消息失败:', error);
    }
  }
  
  /**
   * 处理私聊消息事件
   */
  async handleImMessageEvent(event) {
    console.log('处理私聊消息事件:', event);
    // 在这里实现私聊消息处理逻辑
  }
  
  /**
   * 处理员工变更事件
   */
  async handleEmployeeChangeEvent(event) {
    console.log('处理员工变更事件:', event);
    // 在这里实现员工变更处理逻辑
  }
}

module.exports = new WebhookController(); 